package com.yoshino.principle.liskov_substitution;

import lombok.extern.slf4j.Slf4j;

/**
 * @author yoshino
 **/
@Slf4j
public class LiskovSubstitution {
    public static void main(String[] args) {
        Aa a = new Aa();
        log.info("11 - 3 =" + a.func1(11, 3));
        log.info("1 - 8 =" + a.func1(1, 8));
        log.info("---------------");
        Bb b = new Bb();
        // 因为 B 类不再继承 A 类，因此调用者，不会再 func1 是求减法
        // 调用完成的功能就很明确
        log.info("11 + 3 =" + b.func1(11, 3));
        log.info("1 + 8 =" + b.func1(1, 8));
        log.info("11 + 3 + 9 =" + b.func2(11, 3));

        // 使用组合仍然可以使用到 A 类相关方法
        log.info("11 - 3 =" + b.func3(11, 3));
    }
}

/**
 * 创建一个更加基础的基类
 */
class Base {
    // 把更加基础的方法和成员写到 Base 类
}

class Aa extends Base {
    /**
     * 返回两个数的差
     *
     * @param num1 num1
     * @param num2 num2
     * @return 差值
     */
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}

/**
 * 继承 A 类
 * 增加一个新功能
 */
class Bb extends Base {
    /**
     * 如果 B 需要使用 A 类方法，使用组合关系
     */
    private final Aa a = new Aa();


    public int func1(int a, int b) {// 这里，重写了 A 类的方法，可能是无意识
        return a + b;
    }

    public int func2(int a, int b) {
        return (func1(a, b) + 9);
    }

    public int func3(int a, int b) {// 仍然想要使用 A 的方法
        return this.a.func1(a, b);
    }
}
